#!/usr/bin/env node

const Database = require('better-sqlite3');
const db = new Database('./data/delivery-management.db');

console.log('🔍 深入分析为什么13个对象类有2个不同的分类代码...\n');

try {
  console.log('1. 获取所有重复分类代码的详细信息...');
  
  // 获取有多个分类代码的对象类
  const duplicateClasses = db.prepare(`
    SELECT 
      classification_name,
      specialty,
      COUNT(DISTINCT classification_code) as code_count,
      GROUP_CONCAT(DISTINCT classification_code ORDER BY classification_code) as all_codes
    FROM device_type_mappings
    GROUP BY classification_name, specialty
    HAVING code_count > 1
    ORDER BY classification_name
  `).all();

  console.log(`发现 ${duplicateClasses.length} 个对象类有多个分类代码:`);
  
  duplicateClasses.forEach((cls, index) => {
    console.log(`${index + 1}. ${cls.classification_name} (${cls.specialty}): ${cls.all_codes}`);
  });

  console.log('\n2. 分析分类代码的模式和规律...');
  
  // 详细分析每个重复的分类代码
  duplicateClasses.forEach(cls => {
    console.log(`\n📋 ${cls.classification_name} (${cls.specialty}):`);
    
    const codes = cls.all_codes.split(',');
    console.log(`  分类代码: ${codes.join(' vs ')}`);
    
    // 分析代码模式
    codes.forEach((code, index) => {
      const parts = code.split('-');
      console.log(`  代码${index + 1}: ${code}`);
      console.log(`    层级结构: ${parts.join(' -> ')}`);
      console.log(`    第1级: ${parts[0]} (${getLevel1Meaning(parts[0])})`);
      console.log(`    第2级: ${parts[1]} (${getLevel2Meaning(parts[1])})`);
      if (parts[2] && parts[2] !== '00') console.log(`    第3级: ${parts[2]}`);
      if (parts[3] && parts[3] !== '00') console.log(`    第4级: ${parts[3]}`);
      if (parts[4] && parts[4] !== '00') console.log(`    第5级: ${parts[4]}`);
      if (parts[5] && parts[5] !== '000') console.log(`    第6级: ${parts[5]}`);
    });

    // 获取对应的参数表信息
    const mappings = db.prepare(`
      SELECT classification_code, naming_table, position_table, base_params_table
      FROM device_type_mappings
      WHERE classification_name = ? AND specialty = ?
      ORDER BY classification_code
    `).all(cls.classification_name, cls.specialty);
    
    console.log(`  参数表映射:`);
    mappings.forEach((mapping, index) => {
      console.log(`    代码${index + 1} (${mapping.classification_code}):`);
      console.log(`      位置表: ${mapping.position_table}`);
      console.log(`      基础参数表: ${mapping.base_params_table}`);
    });
  });

  console.log('\n3. 分析代码前缀的含义...');
  
  // 统计所有代码的前缀模式
  const allCodes = [];
  duplicateClasses.forEach(cls => {
    cls.all_codes.split(',').forEach(code => {
      allCodes.push({
        code,
        classification_name: cls.classification_name,
        specialty: cls.specialty,
        level1: code.split('-')[0],
        level2: code.split('-')[1]
      });
    });
  });

  // 按第一级分组
  const level1Groups = {};
  allCodes.forEach(item => {
    if (!level1Groups[item.level1]) {
      level1Groups[item.level1] = [];
    }
    level1Groups[item.level1].push(item);
  });

  console.log(`\n代码第一级分布:`);
  Object.entries(level1Groups).forEach(([level1, items]) => {
    console.log(`  ${level1} (${getLevel1Meaning(level1)}): ${items.length}个代码`);
    
    // 按第二级再分组
    const level2Groups = {};
    items.forEach(item => {
      if (!level2Groups[item.level2]) {
        level2Groups[item.level2] = [];
      }
      level2Groups[item.level2].push(item);
    });
    
    Object.entries(level2Groups).forEach(([level2, level2Items]) => {
      console.log(`    ${level1}-${level2} (${getLevel2Meaning(level2)}): ${level2Items.length}个`);
      if (level2Items.length <= 5) {
        level2Items.forEach(item => {
          console.log(`      ${item.code} - ${item.classification_name}`);
        });
      }
    });
  });

  console.log('\n4. 分析位置表的差异...');
  
  // 检查相同对象类的不同代码是否使用不同的位置表
  console.log(`\n位置表使用情况分析:`);
  duplicateClasses.forEach(cls => {
    const mappings = db.prepare(`
      SELECT classification_code, position_table, base_params_table
      FROM device_type_mappings
      WHERE classification_name = ? AND specialty = ?
      ORDER BY classification_code
    `).all(cls.classification_name, cls.specialty);
    
    const positionTables = [...new Set(mappings.map(m => m.position_table))];
    const baseParamTables = [...new Set(mappings.map(m => m.base_params_table))];
    
    if (positionTables.length > 1 || baseParamTables.length > 1) {
      console.log(`\n  ${cls.classification_name}:`);
      console.log(`    位置表: ${positionTables.join(' vs ')}`);
      console.log(`    基础参数表: ${baseParamTables.join(' vs ')}`);
      
      mappings.forEach(mapping => {
        console.log(`    ${mapping.classification_code} -> 位置表:${mapping.position_table}, 参数表:${mapping.base_params_table}`);
      });
    }
  });

  console.log('\n5. 检查设备表中的实际使用情况...');
  
  // 检查这些重复的分类代码在devices表中是否都有设备
  console.log(`\n设备使用情况:`);
  duplicateClasses.forEach(cls => {
    console.log(`\n  ${cls.classification_name}:`);
    
    const codes = cls.all_codes.split(',');
    codes.forEach(code => {
      const devices = db.prepare(`
        SELECT device_id, name FROM devices WHERE classification_code = ?
      `).all(code);
      
      console.log(`    ${code}: ${devices.length}个设备`);
      if (devices.length > 0) {
        devices.forEach(device => {
          console.log(`      - ${device.device_id}: ${device.name}`);
        });
      }
    });
  });

  console.log('\n6. 总结分析结果...');
  
  console.log(`\n💡 分析结论:`);
  console.log(`1. 编码体系规律:`);
  console.log(`   - L3-xx: 可能是第3级设备编码体系`);
  console.log(`   - L4-xx: 可能是第4级设备编码体系`);
  console.log(`   - L5-xx: 可能是第5级设备编码体系`);
  
  console.log(`\n2. 专业编码规律:`);
  console.log(`   - 07-xx: 可能是容器/储罐相关`);
  console.log(`   - 06-xx: 可能是泵类设备`);
  console.log(`   - 15-xx: 可能是仪表类设备`);
  console.log(`   - 16-xx: 可能是电气类设备`);
  console.log(`   - 17-xx: 可能是通信类设备`);
  
  console.log(`\n3. 可能的原因:`);
  console.log(`   - 不同的设备标准或规范体系`);
  console.log(`   - 设备在不同工程阶段的编码差异`);
  console.log(`   - 历史编码兼容性需求`);
  console.log(`   - 不同厂商或供应商的编码标准`);

} catch (error) {
  console.error('❌ 分析失败:', error.message);
  console.error(error.stack);
} finally {
  db.close();
}

// 辅助函数：解释第一级代码含义
function getLevel1Meaning(level1) {
  const meanings = {
    'L1': '第1级通用',
    'L2': '第2级系统',
    'L3': '第3级子系统',
    'L4': '第4级设备',
    'L5': '第5级组件'
  };
  return meanings[level1] || '未知';
}

// 辅助函数：解释第二级代码含义
function getLevel2Meaning(level2) {
  const meanings = {
    '05': '橇装设备',
    '06': '泵类设备',
    '07': '容器储罐',
    '08': '电气系统',
    '09': '自动化系统',
    '10': '管道系统',
    '13': '阀门',
    '15': '仪表控制',
    '16': '电气设备',
    '17': '通信设备',
    '18': '环保设备',
    '19': '消防设备'
  };
  return meanings[level2] || '未知分类';
}